﻿#include <stdio.h>
#include <stdlib.h>
//// 1. 正常的命名空间定义
//// lj是命名空间的名字，⼀般开发中是⽤项⽬名字做命名空间名。
//namespace lj
//{
//	// 命名空间中可以定义变量/函数/类型
//	int rand = 10;
//	int Add(int left, int right)
//	{
//		return left + right;
//	}
//	struct Node
//	{
//		struct Node* next;
//		int val;
//	};
//}
//int main()
//{
//	// 这⾥默认是访问的是全局的rand函数指针
//	printf("%p\n", rand);
//	// 这⾥指定bit命名空间中的rand
//	printf("%d\n", lj::rand);
//	return 0;
//}
//2. 命名空间可以嵌套
//namespace lj
//{
//	namespace yq
//	{
//		int rand = 1;
//		int Add(int left, int right)
//		{
//			return left + right;
//		}
//	}
//	namespace ls
//	{
//		int rand = 2;
//		int Add(int left, int right)
//		{
//			return (left + right) * 10;
//		}
//	}
//}
//int main()
//{
//	printf("%d\n", lj::yq::rand);
//	printf("%d\n", lj::ls::rand);
//	printf("%d\n", lj::yq::Add(1, 2));
//	printf("%d\n", lj::ls::Add(1, 2));
//	return 0;
//}
// 
// 多⽂件中可以定义同名namespace，他们会默认合并到—起，就像同—个namespace—样
// Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
namespace bit
{
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType* a;
		int top;
		int capacity;
	}ST;
	void STInit(ST* ps, int n);
	void STDestroy(ST* ps);
	void STPush(ST* ps, STDataType x);
	void STPop(ST* ps);
	STDataType STTop(ST* ps);
	int STSize(ST* ps);
	bool STEmpty(ST* ps);
}
// Stack.cpp
#include"Stack.h"
namespace bit
{
	void STInit(ST* ps, int n)
	{
		assert(ps);
		ps->a = (STDataType*)malloc(n * sizeof(STDataType));
		ps->top = 0;
		ps->capacity = n;
	}
	// 栈顶
	void STPush(ST* ps, STDataType x)
	{
		assert(ps);
		// 满了， 扩容
		if (ps->top == ps->capacity)
		{
			printf("扩容\n");
			int newcapacity = ps->capacity == 0 ? 4 : ps->capacity
				* 2;
			STDataType* tmp = (STDataType*)realloc(ps->a,
				newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
		ps->a[ps->top] = x;
		ps->top++;
	}
	//...
}
// Queue.h
#pragma once
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
namespace bit
{
	typedef int QDataType;
	typedef struct QueueNode
	{
		int val;
		struct QueueNode* next;
	}QNode;
	typedef struct Queue
	{
		QNode* phead;
		QNode* ptail;
		int size;
	}Queue;
	void QueueInit(Queue* pq);
	void QueueDestroy(Queue* pq);
	// ⼊队列
	void QueuePush(Queue* pq, QDataType x);
	// 出队列
	void QueuePop(Queue* pq);
	QDataType QueueFront(Queue* pq);
	QDataType QueueBack(Queue* pq);
	bool QueueEmpty(Queue* pq);
	int QueueSize(Queue* pq);
	// Queue.cpp
#include"Queue.h"
	namespace bit
	{
		void QueueInit(Queue* pq)
		{
			assert(pq);
			pq->phead = NULL;
			pq->ptail = NULL;
			pq->size = 0;
		}
		// ...
	}
	// test.cpp
#include"Queue.h"
#include"Stack.h"
// 全局定义了—份单独的Stack
	typedef struct Stack
	{
		int a[10];
		int top;
	}ST;
	void STInit(ST* ps) {}
	void STPush(ST* ps, int x) {}
	int main()
	{
		// 调⽤全局的
		ST st1;
		STInit(&st1);
		STPush(&st1, 1);
		STPush(&st1, 2);
		printf("%d\n", sizeof(st1));
		// 调⽤bit namespace的
		bit::ST st2;
		printf("%d\n", sizeof(st2));
		bit::STInit(&st2);
		bit::STPush(&st2, 1);
		bit::STPush(&st2, 2);
		return 0;
	}